home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Gamer Resource Kit / Hardcore Gamer Resource Kit - Disc 3.iso / screensavers / saver04.zip / track2.c < prev    next >
C/C++ Source or Header  |  1997-07-16  |  58KB  |  2,164 lines
  1. #define GO
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #include <float.h>
  6. #include <time.h>
  7. #include <string.h>
  8. #include <search.h>
  9.  
  10. #include <glide.h>
  11.  
  12. #define Float2Int (int)
  13. #define Int2Float (double)
  14.  
  15.  
  16. #define BOTTOM 479 
  17. #define RIGHT  639 
  18. #define FOV    128 
  19.  
  20. #define PI 3.141592654
  21. #define TRUE 1
  22. #define FALSE 0
  23.  
  24. #define TICK (double)0.3
  25. #define DAMP (double)0.99
  26. #define SLEEP 0
  27. #define WATER 30
  28.  
  29. #define SURFACE 0
  30. #define BLOB    1
  31. #define MASK    2
  32. #define CMASK   3
  33.  
  34. #define MAXVERTEX       750
  35. #define MAXFACE         1400
  36.  
  37. extern    short int  VERTEX,FACE;    
  38. extern    short int  fobject[MAXVERTEX][3];
  39. extern    short int pt[MAXVERTEX][4],facet[MAXFACE][3],current_bin;
  40. extern int facevert, facepoly;
  41.  
  42. extern void loadobject ();
  43.  
  44.  
  45.  
  46. int mode;
  47.  
  48. long sqrttab[0x100]; // declare table of square roots
  49. long isqrttab[0x100]; // declare table of square roots
  50.  
  51. GrMipMapId_t facetexture,
  52.              texture1,
  53.              texture2,
  54.              texture3,
  55.              texture4,
  56.              texture5,
  57.              texture6,
  58.              spotlight,
  59.              cockpit;
  60.  
  61.  
  62. GrMipMapId_t *fgtexture;
  63. GrMipMapId_t *bgtexture;
  64.  
  65.  
  66.  
  67. GrHwConfiguration hwconfig;
  68. GrColorCombineFnc_t cc_fnc;
  69. GrScreenResolution_t    screenRes;
  70.  
  71. float wWidth = 640.0f;
  72. float wHeight = 480.0f;
  73.  
  74. double V        [32][32];
  75. double Fc       [32][32]; /* Centering Force */
  76. double Fn       [32][32]; /* Neihboring Force */
  77.  
  78.  
  79.  
  80.   typedef struct {
  81.      double  x, y, z;
  82.  } point;
  83.  
  84.  typedef struct {
  85.      point     pt[3];    /* Vertices of triangle */
  86.      double    area;     /* Unused; might be used for adaptive subdivision */
  87.  } triangle;
  88.  
  89.  typedef struct {
  90.      int       npoly;    /* # of triangles in object */
  91.      triangle *poly;     /* Triangles */
  92.  } object;
  93.  
  94. int gid; /* Global Object id */
  95.  
  96.  
  97. unsigned char *screen; 
  98. char screen_buff[640*480];
  99. int max = 10; 
  100. unsigned int ADDR; 
  101. int width,height; 
  102. char filename[80]; 
  103. int debug; 
  104. int count; 
  105. FILE* fp; 
  106. int bad; 
  107.  
  108. /* Camera POV */ 
  109. double cx,cy,cz; 
  110. int    theta; 
  111.  
  112. int ltheta; 
  113. int rtheta; 
  114. int ftheta; 
  115. double tpx,tpy; /* Test points */ 
  116. double axl,byl,cl; 
  117. double axr,byr,cr; 
  118. double axf,byf,cf; 
  119. double lsign, rsign, fsign; 
  120.  
  121.  
  122.  /*----- constants*/ 
  123. #define MAXDEGREES 1024 
  124. #define EYE_DISTANCE Int2Fixed(256) 
  125. #define MAXVERTICES 2000 
  126. #define MAXPOLYGONS 2100 
  127. #define MAXPOLYVERT 3
  128.  
  129. double Fcb [MAXVERTICES];
  130. double Vb  [MAXVERTICES];
  131. double Fnb [MAXVERTICES];
  132.  
  133. /*----- these are for the gouraud shading routines ----*/ 
  134. int ledge_x[480]; /* x coordinate for left edge*/ 
  135. int ledge_color[480]; /* color for left edge*/ 
  136.  
  137. int redge_x[480]; /* destination x coordinate for right edge*/ 
  138. int redge_color[480]; /* color for right edge*/ 
  139.  
  140. /*----- these are for the basic graphics routines*/ 
  141. int ytable[480]; /* so u can do ytable[y]+x (fast), instead of y*320+x (slow)*/ 
  142.  
  143.  
  144. /*----- 16.16 fixedpoint trig lookup tables*/ 
  145. double cosine[MAXDEGREES]; /* cosine lookup table*/ 
  146. double sine[MAXDEGREES];  /* sine lookup table*/ 
  147. double polar_lut [MAXDEGREES]; /* LUT for sin/cos theta near x-axis */ 
  148. double dsine [MAXDEGREES]; 
  149. double dcosine [MAXDEGREES]; 
  150.  
  151. /*----- angle and position of 3d object*/ 
  152. int xangle,yangle,zangle; /* angles of rotation*/ 
  153. double xpos,ypos,zpos; /* position of object in 3d*/ 
  154.  
  155.  
  156. /* structure of one vertex*/ 
  157. typedef struct 
  158. { 
  159.   double s,t;      /* Texture co-ordinates */
  160.   double ox,oy,oz; /* vertex original coordinates*/ 
  161.   double wx,wy,wz; /* vertex working coordinates*/ 
  162.   double Nox,Noy,Noz; /* vertex normal original coordinatesv*/ 
  163.   double SNox,SNoy,SNoz; /* vertex normal original coordinates - blob*/ 
  164.   double xlen,ylen,zlen;
  165.   int    vcount;
  166.   double Nwx,Nwy,Nwz; /* vertex normal working coordinates*/ 
  167.   int sx,sy,sz; /* vertex screen coordinates*/ 
  168.   int color; /* color of vertex normal*/ 
  169. } VertexTYPE; 
  170.  
  171. /* structure of one polygon*/ 
  172. typedef struct 
  173. { 
  174.   int texture_type ; /* 0 = flat colour, 1 = Gouraud, 2 = Texture */ 
  175.   int NumOfVertices; /* number of vertices that make up the polygon*/ 
  176.   int Vertex[MAXPOLYVERT]; /* vertex indices in counter clockwise order*/ 
  177.   int zcenter; /* for sorting*/ 
  178.   double Nox,Noy,Noz; /* polygon normals (only used for ver normals)*/ 
  179. } PolygonTYPE; 
  180.  
  181. /* object structure*/ 
  182. typedef struct 
  183. { 
  184.   double Ox,Oy,Oz; /* coordinates of object's origin*/ 
  185.   int Ax,Ay,Az; /* object's rotation angles*/ 
  186.   int NumOfVertices; /* number of vertices in object*/ 
  187.   VertexTYPE Vertex[MAXVERTICES]; /* all vertices in object*/ 
  188.   int NumOfPolygons; /* number of polygons in object*/ 
  189.   PolygonTYPE Polygon[MAXPOLYGONS]; /* all polygons in object*/ 
  190. } ObjectTYPE; 
  191.  
  192. ObjectTYPE Object; /* one object - THIS IS THE WATER */ 
  193.  
  194. /* structure of light source*/ 
  195. typedef struct 
  196. { 
  197.   double x,y,z; /* coodinates of light source*/ 
  198.   double wx,wy,wz; /* working (intermediate) coordinates*/ 
  199.   int ax,ay,az; /* rotation angles*/ 
  200. } LightSourceTYPE; 
  201.  
  202. LightSourceTYPE LightSource; /* one light source*/ 
  203.  
  204. int NumOfSortedPolygons; /* number of sorted visible polygons*/ 
  205. int NumOfViewedPolygons; /* number of sorted visible polygons*/ 
  206. int PolygonOrderList[MAXPOLYGONS]; /* list of polygon indices for qsorting*/ 
  207. int PolygonOrderClip[MAXPOLYGONS]; /* list of polygon indices for qsorting*/ 
  208. int PolygonViewList[MAXPOLYGONS];  /* list of polygon indices in view */ 
  209. int PolygonViewClip[MAXPOLYGONS];  /* list of polygon indices in view */ 
  210.  
  211.  
  212.  
  213. double xpath[MAXVERTICES]; 
  214. double ypath[MAXVERTICES]; 
  215. double zpath[MAXVERTICES]; 
  216. int    thetapath[MAXVERTICES]; 
  217.  
  218.  
  219. /*---------------------- function prototypes ------------------------*/ 
  220. int main(int argc,char**argv); 
  221. int  Visible (); 
  222. void CalcViewTriangle(); 
  223. void Demo(); 
  224.  
  225. void DrawGouraudPolygon(PolygonTYPE *poly);
  226. void plot_tri_3dfx();
  227. void plot_poly_3dfx();
  228. void plot_bg();
  229. void bench();
  230.  
  231. int  Load3dfxTexture();
  232.  
  233. void InitYTable(void); 
  234. void InitTrigTables(void); 
  235. void ClearVertexList(); 
  236. void Random(); 
  237. void RotatePoints(); 
  238. void RotateNormals(); 
  239. void DrawObject(); 
  240. void MakeViewPolygonList(); 
  241. void MakeCulledPolygonList(); 
  242. void SortPolygonList(); 
  243. int _cdecl ComparePolygons(const void *a, const void *b);
  244. void InitLightSource(void); 
  245. void CalculateColor(); 
  246. void identity(); 
  247. void multiply(); 
  248.  
  249.  
  250. /*-------------------------------------------------------------------*/
  251.  
  252.  
  253.  
  254.  
  255. int
  256. DoFace()
  257. {
  258. object *obj;
  259. int i,j,k,found;
  260. double x,y,z;
  261. double max=-99999.9,min=99999.9;
  262.  
  263.   loadobject();
  264.  
  265.  
  266.   Object.NumOfVertices = 0;
  267.   Object.NumOfPolygons = 0;
  268.  
  269.   for (i=0;i<MAXVERTICES;i++)
  270.     Object.Vertex[i].ox = 0;
  271.  
  272.   /* For all poly's in list extract vertices  */
  273.   for (i=0;i<facevert;i++)
  274.   {
  275.       z = (double)fobject[i][0]/4.0;
  276.       y = (double)fobject[i][1]/4.0;
  277.       x = (double)fobject[i][2]/4.0;
  278.       
  279.       k = 0;
  280.       found = FALSE;
  281.       while (k<Object.NumOfVertices && found == FALSE)
  282.       {
  283.         if (Object.Vertex[k].ox == x &&
  284.             Object.Vertex[k].oy == y &&
  285.             Object.Vertex[k].oz == z ) 
  286.          found = TRUE;
  287.         else 
  288.           k++;
  289.       }
  290.    
  291.       /* add vertex to list */
  292.       if (found == FALSE)
  293.       {
  294.         Object.Vertex[k].ox = x;
  295.         Object.Vertex[k].oy = y;
  296.         Object.Vertex[k].oz = z;
  297.  
  298.         Object.Vertex[k].s = 137.0 +(127.0/40.5) *z; /* Adjust height wise */
  299.         Object.Vertex[k].t = 201.0 +(127.0/37.0) * -x; /* Adjust width wise */
  300.  
  301.         Object.NumOfVertices ++;
  302.         
  303.       }
  304.     }
  305.  
  306.   
  307.   printf("Unique vertices = %d (%d) \n",
  308.          Object.NumOfVertices,3*facevert);
  309.  
  310.   x = y = z = 0.0;
  311.   for (i=0;i<Object.NumOfVertices;i++)
  312.   {
  313.     x += Object.Vertex[i].ox;
  314.     y += Object.Vertex[i].oy;
  315.     z += Object.Vertex[i].oz;
  316.   }
  317.   x=x/(double)Object.NumOfVertices;
  318.   y=y/(double)Object.NumOfVertices;
  319.   z=z/(double)Object.NumOfVertices;
  320.  
  321.   printf("Average = %f %f %f\n",x,y,z);
  322.   
  323.   for (i=0;i<Object.NumOfVertices;i++)
  324.   {
  325.     Object.Vertex[i].ox-=x;
  326.     Object.Vertex[i].oy-=y;
  327.     Object.Vertex[i].oz-=z;
  328.   }
  329.  
  330.   for (i=0;i<facepoly;i++)
  331.   {
  332.     Object.Polygon[i].Vertex[0] = facet[i][0];
  333.     Object.Polygon[i].Vertex[1] = facet[i][2];
  334.     Object.Polygon[i].Vertex[2] = facet[i][1];
  335.     
  336.     Object.Polygon[i].NumOfVertices = 3;
  337.     Object.NumOfPolygons ++;
  338.   }
  339.  
  340.   printf("Number of polys %d\n\n",Object.NumOfPolygons);
  341. }
  342.  
  343.  
  344.  
  345.  
  346. void
  347. DoSphere(int level)
  348. {
  349. object *obj;
  350. int i,j,k,found;
  351. double x,y,z;
  352. double maxx,minx;
  353.  
  354. maxx=-999.9;
  355. minx=999.9;
  356.  
  357.   obj = sphere(level);
  358.  
  359.   Object.NumOfVertices = 0;
  360.   Object.NumOfPolygons = 0;
  361.  
  362.   for (i=0;i<MAXVERTICES;i++)
  363.     Object.Vertex[i].ox = 0;
  364.  
  365.   /* For all poly's in list extract vertices  */
  366.   for (i=0;i<obj->npoly;i++)
  367.   {
  368.     for (j=0;j<3;j++)
  369.     {
  370.       x = obj->poly[i].pt[j].x*(double)20.0;
  371.       y = obj->poly[i].pt[j].y*(double)20.0;
  372.       z = obj->poly[i].pt[j].z*(double)20.0;
  373.  
  374.       found = FALSE;
  375.       k = 0;
  376.       while (k<Object.NumOfVertices && found == FALSE)
  377.       {
  378.         if (Object.Vertex[k].ox == x &&
  379.             Object.Vertex[k].oy == y &&
  380.             Object.Vertex[k].oz == z ) 
  381.          found = TRUE;
  382.         else 
  383.           k++;
  384.       }
  385.    
  386.       /* add vertex to list */
  387.       if (found == FALSE)
  388.       {
  389.         Object.Vertex[k].ox = x;
  390.         Object.Vertex[k].oy = y;
  391.         Object.Vertex[k].oz = z;
  392.  
  393.         Object.Vertex[k].s = 127.0 +(127.0/20.0) * x;
  394.         Object.Vertex[k].t = 127.0 +(127.0/20.0) * y;
  395.  
  396.         if (x > maxx) maxx = x;
  397.         if (x< minx) minx = x;
  398.  
  399.         
  400.         Object.NumOfVertices ++;
  401.       }
  402.     }
  403.   }
  404.   printf("MAX %f MIN %f \n",maxx,minx);
  405.   printf("Unique vertices = %d (%d) \n",
  406.          Object.NumOfVertices,3*obj->npoly);
  407.  
  408.  
  409.   for (i=0;i<obj->npoly;i++)
  410.   {
  411.     for (j=0;j<3;j++)
  412.     {
  413.       x = obj->poly[i].pt[j].x*(double)20.0;
  414.       y = obj->poly[i].pt[j].y*(double)20.0;
  415.       z = obj->poly[i].pt[j].z*(double)20.0;
  416.  
  417.       k = 0;found = FALSE;
  418.       while (k<Object.NumOfVertices && found == FALSE) 
  419.       {
  420.         if (Object.Vertex[k].ox == x &&
  421.             Object.Vertex[k].oy == y &&
  422.             Object.Vertex[k].oz == z ) 
  423.           found = TRUE;
  424.         else 
  425.           k++;
  426.       }
  427.       if (k == Object.NumOfVertices) printf("OH DEAR!\n");
  428.  
  429.       Object.Polygon[i].Vertex[j] = k;
  430.     }
  431.     Object.Polygon[i].NumOfVertices = 3;
  432.   }
  433.   Object.NumOfPolygons = i;
  434.  printf("Number of polys %d\n\n",Object.NumOfPolygons);
  435. }
  436.  
  437.  
  438.  
  439.  
  440. void build_table(void) {
  441.     unsigned short i;
  442.     float f;
  443.     unsigned int *fi = (unsigned*)&f;   // To access the bits of a float in
  444.                                         // C quickly we must misuse pointers
  445.     for (i = 0; i <= 0x7f; i++) {
  446.         *fi = 0;
  447.  
  448.             // Build a float with the bit pattern i as mantissa
  449.             // and an exponent of 0, stored as 127
  450.         *fi = (i << 16) | (127 << 23);
  451.         f = sqrt(f);
  452.  
  453.             // Take the square root then strip the first 7 bits of
  454.             // the mantissa into the table
  455.         sqrttab[i] = (*fi & 0x7fffff);
  456.  
  457.             // Repeat the process, this time with an exponent of 1,
  458.             // stored as 128
  459.         *fi = 0;
  460.         *fi = (i << 16) | (128 << 23);
  461.         f = sqrt(f);
  462.         sqrttab[i+0x80] = (*fi & 0x7fffff);
  463.     }
  464. }
  465.  
  466. void build_itable(void) {
  467.     unsigned short i;
  468.     float f;
  469.     unsigned int *fi = (unsigned*)&f;   // To access the bits of a float in
  470.                                         // C quickly we must misuse pointers
  471.     for (i = 0; i <= 0x7f; i++) {
  472.         *fi = 0;
  473.  
  474.             // Build a float with the bit pattern i as mantissa
  475.             // and an exponent of 0, stored as 127
  476.         *fi = (i << 16) | (127 << 23);
  477.         f = 1.0/sqrt(f);
  478.  
  479.             // Take the square root then strip the first 7 bits of
  480.             // the mantissa into the table
  481.         isqrttab[i] = (*fi & 0x7fffff);
  482.  
  483.             // Repeat the process, this time with an exponent of 1,
  484.             // stored as 128
  485.         *fi = 0;
  486.         *fi = (i << 16) | (128 << 23);
  487.         f = 1.0/sqrt(f);
  488.         isqrttab[i+0x80] = (*fi & 0x7fffff);
  489.     }
  490. }
  491.  
  492.  
  493.  
  494.     // fsqrt - fast square root by table lookup, original C version
  495. float fsqrt(float n) {
  496.     unsigned int *num = (unsigned *)&n; // to access the bits of a float in C
  497.                                         // we must misuse pointers
  498.  
  499.     short e;        // the exponent
  500.     if (n == 0) return (0); /* check for square root of 0 */
  501.     e = (*num >> 23) - 127; /* get the exponent - on a SPARC the */
  502.                             /* exponent is stored with 127 added */
  503.     *num &= 0x7fffff;   /* leave only the mantissa */
  504.     if (e & 0x01) *num |= 0x800000;
  505.                 /* the exponent is odd so we have to */
  506.                 /* look it up in the second half of  */
  507.                 /* the lookup table, so we set the high bit */
  508.     e >>= 1;    /* divide the exponent by two */
  509.                 /* note that in C the shift */
  510.                 /* operators are sign preserving */
  511.                 /* for signed operands */
  512.         // Do the table lookup, based on the quaternary mantissa,
  513.         // then reconstruct the result back into a float
  514.     *num = ((sqrttab[*num >> 16])) + ((e + 127) << 23);
  515.     return(n);
  516. }
  517.  
  518.  
  519. float fisqrt(float n) {
  520.     unsigned int *num = (unsigned *)&n; // to access the bits of a float in C
  521.                                         // we must misuse pointers
  522.  
  523.     short e;        // the exponent
  524.     if (n == 0) return (0); /* check for square root of 0 */
  525.     e = (*num >> 23) - 127; /* get the exponent - on a SPARC the */
  526.                             /* exponent is stored with 127 added */
  527.     *num &= 0x7fffff;   /* leave only the mantissa */
  528.     if (e & 0x01) *num |= 0x800000;
  529.                 /* the exponent is odd so we have to */
  530.                 /* look it up in the second half of  */
  531.                 /* the lookup table, so we set the high bit */
  532.     e >>= 1;    /* divide the exponent by two */
  533.                 /* note that in C the shift */
  534.                 /* operators are sign preserving */
  535.                 /* for signed operands */
  536.         // Do the table lookup, based on the quaternary mantissa,
  537.         // then reconstruct the result back into a float
  538.     *num = ((isqrttab[*num >> 16])) + ((e + 127) << 23);
  539.     return(n);
  540. }
  541.  
  542.  
  543.  
  544.  
  545.  
  546. int
  547. init()
  548. {
  549.   int x,y,i;
  550.  
  551.   for (x = 0; x< WATER; x++)
  552.   {
  553.     for (y=0; y<WATER; y++)
  554.     {
  555.       V [x][y] = 0.0;
  556.     }
  557.   }
  558.  
  559.    for (x = 0; x< Object.NumOfVertices; x++)
  560.     Vb [x] = 0.0;
  561.  
  562.   Vb[rand()%Object.NumOfVertices] = 7.0;
  563.   Vb[rand()%Object.NumOfVertices] = 7.0;
  564.  
  565.   Vb[rand()%Object.NumOfVertices] = 7.0;
  566.   Vb[rand()%Object.NumOfVertices] = 7.0;
  567.  
  568.   Vb[rand()%Object.NumOfVertices] = 7.0;
  569.   Vb[rand()%Object.NumOfVertices] = 7.0;
  570.  
  571.  
  572.  
  573.   V[WATER/2][WATER/2] = 8.0;
  574.   V[WATER/2-1][WATER/2] = 8.0;
  575.   V[WATER/2-1][WATER/2-1] = 8.0;
  576.   V[WATER/2][WATER/2-1] = 8.0;
  577.   /*V[15][15] = 5.0;*/
  578.  
  579. }
  580.  
  581.  
  582. int 
  583. calcFc(int mode)
  584. {
  585.   int x,y;
  586.   double max,roottwo;
  587.   roottwo = 1.0 / sqrt(2.0);
  588.  
  589.   max = -99999.99;
  590.  
  591.   if (mode == SURFACE)
  592.   {
  593.     for (x = 0; x< WATER; x++)
  594.     {
  595.       for (y=0; y<WATER; y++)
  596.       {
  597.         /*Fc [x][y] = Object.Vertex[x+y*WATER].ox /15.0;
  598.         Fc [x][y] = 0.1*fabs(Object.Vertex[x+y*WATER].ox) * Object.Vertex[x+y*WATER].ox;*/
  599.         Fc [x][y] = Object.Vertex[x+y*WATER].ox;
  600.       }
  601.     }
  602.  
  603.     for (x = 1; x< WATER; x++)
  604.     {
  605.       for (y=1; y<WATER; y++)
  606.       {
  607.         Fn [x][y]=(roottwo*Fc[x-1][y-1]) + Fc[x][y-1] + (roottwo*Fc[x+1][y-1])+
  608.                         Fc[x-1][y]    +   0.0*Fc[x][y] +   Fc[x+1][ y]   +
  609.                   (roottwo*Fc[x-1][y+1]) + Fc[x][y+1] + (roottwo*Fc[x+1][y+1]) ;
  610.         Fn [x][y] = Fn [x][y]/(4.0+roottwo*4.0);
  611.  
  612.         V[x][y] += TICK * (Fn[x][y] - Fc[x][y]) /* Accel */;
  613.         V[x][y] *= DAMP; /* Damping */
  614.         Object.Vertex[x+y*WATER].ox+=TICK * V[x][y];
  615.       }
  616.     }
  617.   }
  618.   else if (mode == BLOB)
  619.   {
  620.  for (x = Object.NumOfVertices-1; x>=0; x--)
  621.   {
  622.     Fcb [x] = sqrt(Object.Vertex[x].ox*Object.Vertex[x].ox + 
  623.                    Object.Vertex[x].oy*Object.Vertex[x].oy +
  624.                    Object.Vertex[x].oz*Object.Vertex[x].oz );
  625.     Object.Vertex[x].vcount = 0.0;
  626.     Fnb [x] = 0.0;
  627.   }
  628.  
  629.   /* for each polygon .. */
  630.   for (x = Object.NumOfPolygons-1; x>=0; x--)
  631.   {
  632.     for (y=2;y>=0;y--) /* for each vertex */
  633.     {
  634.       Fnb [Object.Polygon[x].Vertex[y]] += 
  635.           (Fcb[Object.Polygon[x].Vertex[(y+1)%3]] + 
  636.            Fcb[Object.Polygon[x].Vertex[(y+2)%3]])/2.0  ;
  637.  
  638. /* printf("Poly %d  Vertex %d (%d) = %f\n",
  639.         x,y,Object.Polygon[x].Vertex[y],
  640.         Fnb [Object.Polygon[x].Vertex[y]]) ; */
  641.  
  642.       Object.Vertex[Object.Polygon[x].Vertex[y]].vcount += 1.0;
  643.     }
  644.   }
  645.  
  646.   for (x = Object.NumOfVertices-1; x>=0; x--)
  647.   {
  648.     Fnb [x] = Fnb [x] / Object.Vertex[x].vcount ;
  649.  
  650. /*
  651.  printf("Fnb[%d] = %f / %f = %f\n",
  652.         x,Fnb[x],Object.Vertex[x].vcount,
  653.         Fnb[x]); 
  654. */
  655.  
  656.   /* printf("Fnb =  %lf   Fcb = %lf\n",
  657.           Fnb[x],Fcb[x]); */
  658.  
  659.       Vb[x] += TICK * (Fnb[x] - Fcb[x]) /* Accel */;
  660.       Vb[x] *= DAMP; /* Damping */
  661.       Object.Vertex[x].ox+= Object.Vertex[x].ox * ((TICK * Vb[x])/Fnb[x]);
  662.       Object.Vertex[x].oy+= Object.Vertex[x].oy * ((TICK * Vb[x])/Fnb[x]);
  663.       Object.Vertex[x].oz+= Object.Vertex[x].oz * ((TICK * Vb[x])/Fnb[x]);
  664.   }
  665.  
  666.   }
  667.     
  668. }
  669.  
  670.  
  671.  
  672.  
  673. /*----------------------------------------------------------------------*/
  674.  
  675. void InitTrigTables(void) 
  676. { 
  677.   int i; 
  678.   for(i=0; i<MAXDEGREES; i++) 
  679.   { 
  680.     cosine[i]=(cos((double)i*(double)360/MAXDEGREES * 
  681.             (double)3.14159265 /(double)180.0)); 
  682.     sine[i] =(sin((double)i*(double)360/MAXDEGREES * 
  683.                (double)3.14159265 / (double)180.0)); 
  684.  
  685.     dsine[i] = (sin((double)i*(double)360/MAXDEGREES * 
  686.                (double)PI/(double)180.0)); 
  687.     dcosine[i] = (cos((double)i*(double)360/MAXDEGREES * 
  688.             (double)PI/(double)180.0)); 
  689.  
  690.     if (qabs(256-i)>128 && 
  691.         qabs(768-i)>128) 
  692.       polar_lut[i] = (sin((double)i*(double)360/MAXDEGREES * 
  693.                (double)PI/(double)180.0)) / 
  694.                  (cos((double)i*(double)360/MAXDEGREES * 
  695.             (double)PI/(double)180.0)); 
  696.     else  
  697.       polar_lut[i] = (cos((double)i*(double)360/MAXDEGREES * 
  698.             (double)PI /(double)180.0)) / 
  699.                  (sin((double)i*(double)360/MAXDEGREES * 
  700.                (double)PI/(double)180.0)); 
  701.   } 
  702. } 
  703.  
  704. void InitYTable(void) 
  705. { 
  706.   int i; 
  707.   for(i=0;i<480;i++) 
  708.   { 
  709.   ytable[i]=i*640; 
  710.   } 
  711. } 
  712.  
  713. /*----------------------------------------------------------------------*/ 
  714.  
  715.  
  716. void FInitNormals() 
  717. { 
  718.   register double x1,x2,x3,y1,y2,y3,z1,z2,z3,length;
  719.   register double xlen,ylen,zlen; 
  720.   register int i,j,k; 
  721.  
  722.   /*printf(" first calculate the polygon normals\n"); */
  723.   for(i = Object.NumOfPolygons-1;i>=0 ;i--) 
  724.   { 
  725.     x1=(Object.Vertex[Object.Polygon[i].Vertex[0]].ox); 
  726.     x2=(Object.Vertex[Object.Polygon[i].Vertex[1]].ox); 
  727.     x3=(Object.Vertex[Object.Polygon[i].Vertex[2]].ox); 
  728.     y1=(Object.Vertex[Object.Polygon[i].Vertex[0]].oy); 
  729.     y2=(Object.Vertex[Object.Polygon[i].Vertex[1]].oy); 
  730.     y3=(Object.Vertex[Object.Polygon[i].Vertex[2]].oy); 
  731.     z1=(Object.Vertex[Object.Polygon[i].Vertex[0]].oz); 
  732.     z2=(Object.Vertex[Object.Polygon[i].Vertex[1]].oz); 
  733.     z3=(Object.Vertex[Object.Polygon[i].Vertex[2]].oz); 
  734.    
  735.     /* calculate perpendicular via the cross product of 1st vertex & normal*/ 
  736.     xlen = (y1-y2)*(z1-z3) - (z1-z2)*(y1-y3); 
  737.     ylen = (z1-z2)*(x1-x3) - (x1-x2)*(z1-z3); 
  738.     zlen = (x1-x2)*(y1-y3) - (y1-y2)*(x1-x3); 
  739.     
  740.     /* calculate the length of the normal*/ 
  741.     length = 1.0/sqrt(xlen*xlen + ylen*ylen + zlen*zlen); 
  742.  
  743.     /* scale it to a unit normal*/ 
  744.     if (length!=0.0) 
  745.     { 
  746.       Object.Polygon[i].Nox = (xlen * length); 
  747.       Object.Polygon[i].Noy = (ylen * length); 
  748.       Object.Polygon[i].Noz = (zlen * length); 
  749.     } 
  750.   } 
  751.  
  752.  
  753.   /*This will calculate the normals of the vertices for environment mapping*/ 
  754.   for(i= Object.NumOfVertices-1;i>=0; i--) 
  755.   { 
  756.     Object.Vertex[i].xlen = 0.0;
  757.     Object.Vertex[i].ylen = 0.0;
  758.     Object.Vertex[i].zlen = 0.0;
  759.     Object.Vertex[i].vcount = 0;
  760.   }
  761.  
  762.    
  763.   for(j = Object.NumOfPolygons-1;j>=0 ;j--) 
  764.   { 
  765.     for(k=Object.Polygon[j].NumOfVertices-1;k>=0;k--) 
  766.     { 
  767.         Object.Vertex[Object.Polygon[j].Vertex[k]].xlen += Object.Polygon[j].Nox;
  768.         Object.Vertex[Object.Polygon[j].Vertex[k]].ylen += Object.Polygon[j].Noy;
  769.         Object.Vertex[Object.Polygon[j].Vertex[k]].zlen += Object.Polygon[j].Noz;
  770.         Object.Vertex[Object.Polygon[j].Vertex[k]].vcount ++;
  771.     } 
  772.   } 
  773.    
  774.   for(i= Object.NumOfVertices-1;i>=0; i--) 
  775.   { 
  776.     if(Object.Vertex[i].vcount >0) 
  777.     { 
  778.       Object.Vertex[i].xlen=Object.Vertex[i].xlen/(double)Object.Vertex[i].vcount;
  779.       Object.Vertex[i].ylen=Object.Vertex[i].ylen/(double)Object.Vertex[i].vcount;
  780.       Object.Vertex[i].zlen=Object.Vertex[i].zlen/(double)Object.Vertex[i].vcount;
  781.     } 
  782.  
  783.     length = 1.0/sqrt(Object.Vertex[i].xlen*Object.Vertex[i].xlen +
  784.                    Object.Vertex[i].ylen*Object.Vertex[i].ylen +
  785.                    Object.Vertex[i].zlen*Object.Vertex[i].zlen );
  786.    
  787.     if (length !=0.0)
  788.     { 
  789.       Object.Vertex[i].Nox = (Object.Vertex[i].xlen * length); 
  790.       Object.Vertex[i].Noy = (Object.Vertex[i].ylen * length); 
  791.       Object.Vertex[i].Noz = (Object.Vertex[i].zlen * length);
  792.     } 
  793.   }
  794. } 
  795.  
  796.  
  797. void InitNormals() 
  798. { 
  799.   register double x1,x2,x3,y1,y2,y3,z1,z2,z3,length;
  800.   register double xlen,ylen,zlen; 
  801.   register int i,j,k; 
  802.  
  803.   /*printf(" first calculate the polygon normals\n"); */
  804.   for(i = Object.NumOfPolygons-1;i>=0 ;i--) 
  805.   { 
  806.     x1=(Object.Vertex[Object.Polygon[i].Vertex[0]].ox); 
  807.     x2=(Object.Vertex[Object.Polygon[i].Vertex[1]].ox); 
  808.     x3=(Object.Vertex[Object.Polygon[i].Vertex[2]].ox); 
  809.     y1=(Object.Vertex[Object.Polygon[i].Vertex[0]].oy); 
  810.     y2=(Object.Vertex[Object.Polygon[i].Vertex[1]].oy); 
  811.     y3=(Object.Vertex[Object.Polygon[i].Vertex[2]].oy); 
  812.     z1=(Object.Vertex[Object.Polygon[i].Vertex[0]].oz); 
  813.     z2=(Object.Vertex[Object.Polygon[i].Vertex[1]].oz); 
  814.     z3=(Object.Vertex[Object.Polygon[i].Vertex[2]].oz); 
  815.    
  816.     /* calculate perpendicular via the cross product of 1st vertex & normal*/ 
  817.     xlen = (y1-y2)*(z1-z3) - (z1-z2)*(y1-y3); 
  818.     ylen = (z1-z2)*(x1-x3) - (x1-x2)*(z1-z3); 
  819.     zlen = (x1-x2)*(y1-y3) - (y1-y2)*(x1-x3); 
  820.     
  821.     /* calculate the length of the normal*/ 
  822.     length = 1.0/sqrt(xlen*xlen + ylen*ylen + zlen*zlen); 
  823.  
  824.     /* scale it to a unit normal*/ 
  825.     if (length!=0.0) 
  826.     { 
  827.       Object.Polygon[i].Nox = (xlen * length); 
  828.       Object.Polygon[i].Noy = (ylen * length); 
  829.       Object.Polygon[i].Noz = (zlen * length); 
  830.     } 
  831.   } 
  832.  
  833.  
  834.   /*This will calculate the normals of the vertices for environment mapping*/ 
  835.   for(i= Object.NumOfVertices-1;i>=0; i--) 
  836.   { 
  837.     Object.Vertex[i].xlen = 0.0;
  838.     Object.Vertex[i].ylen = 0.0;
  839.     Object.Vertex[i].zlen = 0.0;
  840.     Object.Vertex[i].vcount = 0;
  841.   }
  842.  
  843.    
  844.   for(j = Object.NumOfPolygons-1;j>=0 ;j--) 
  845.   { 
  846.     for(k=Object.Polygon[j].NumOfVertices-1;k>=0;k--) 
  847.     { 
  848.         Object.Vertex[Object.Polygon[j].Vertex[k]].xlen += Object.Polygon[j].Nox;
  849.         Object.Vertex[Object.Polygon[j].Vertex[k]].ylen += Object.Polygon[j].Noy;
  850.         Object.Vertex[Object.Polygon[j].Vertex[k]].zlen += Object.Polygon[j].Noz;
  851.         Object.Vertex[Object.Polygon[j].Vertex[k]].vcount ++;
  852.     } 
  853.   } 
  854.    
  855.   for(i= Object.NumOfVertices-1;i>=0; i--) 
  856.   { 
  857.     if(Object.Vertex[i].vcount >0) 
  858.     { 
  859.       Object.Vertex[i].xlen=Object.Vertex[i].xlen/(double)Object.Vertex[i].vcount;
  860.       Object.Vertex[i].ylen=Object.Vertex[i].ylen/(double)Object.Vertex[i].vcount;
  861.       Object.Vertex[i].zlen=Object.Vertex[i].zlen/(double)Object.Vertex[i].vcount;
  862.     } 
  863.  
  864.     length = 1.0/sqrt(Object.Vertex[i].xlen*Object.Vertex[i].xlen +
  865.                    Object.Vertex[i].ylen*Object.Vertex[i].ylen +
  866.                    Object.Vertex[i].zlen*Object.Vertex[i].zlen );
  867.    
  868.     if (length !=0.0)
  869.     { 
  870.       Object.Vertex[i].SNox = (Object.Vertex[i].xlen * length); 
  871.       Object.Vertex[i].SNoy = (Object.Vertex[i].ylen * length); 
  872.       Object.Vertex[i].SNoz = (Object.Vertex[i].zlen * length);
  873.     } 
  874.   }
  875. } 
  876.  
  877.  
  878.  
  879.  
  880.  
  881. void RotateNormals() 
  882. { 
  883.   int i; 
  884.   double nx,ny,nz,cosxangle,sinxangle,cosyangle, 
  885.              sinyangle,coszangle,sinzangle; 
  886.   VertexTYPE *vert; /* pointer to a vertex structure*/ 
  887.  
  888.   /* get sine and cosine angles to save time from table lookup in inner loop*/ 
  889.   sinxangle=sine[xangle]; 
  890.   cosxangle=cosine[xangle]; 
  891.   sinyangle=sine[yangle]; 
  892.   cosyangle=cosine[yangle]; 
  893.   sinzangle=sine[zangle]; 
  894.   coszangle=cosine[zangle]; 
  895.  
  896.   for(i=0;i<Object.NumOfVertices;i++) 
  897.   { 
  898.     vert=&Object.Vertex[i]; 
  899.  
  900.   /* rotate around the x-axis */ 
  901.   vert->Nwz=(vert->Noy * cosxangle) - (vert->Noz * sinxangle); 
  902.   vert->Nwy=(vert->Noy * sinxangle) + (vert->Noz * cosxangle); 
  903.   vert->Nwx=vert->Nox; 
  904.  
  905.   /* rotate around the y-axis */ 
  906.   vert->Nwx = (vert->Nwx * cosyangle) - (vert->Nwz * sinyangle); 
  907.   nz = (vert->Nwx * sinyangle) + (vert->Nwz * cosyangle); 
  908.   vert->Nwz=nz; 
  909.  
  910.   /* rotate around the z-axis */ 
  911.   nx=(vert->Nwx * coszangle) - (vert->Nwy * sinzangle); 
  912.   ny=(vert->Nwx * sinzangle) + (vert->Nwy * coszangle); 
  913.  
  914.   /* reverse the direction of the normals for lightsource shading*/ 
  915.   vert->Nwx=nx; vert->Nwy=ny; vert->Nwz=nz; 
  916.   } 
  917. } 
  918.  
  919. /*-------------------------- calculate color of vertex normal ----------*/ 
  920.  
  921.  
  922.  
  923. void DrawGouraudPolygon(PolygonTYPE *poly)
  924. {
  925.         /*Plot a triangle!*/
  926.     printf("?\n");
  927.         if (poly->NumOfVertices ==3 /*&&  CHROME MASK mode != MASK*/)
  928.         {
  929.           plot_tri_3dfx(poly);
  930.         }
  931.         else
  932.         {
  933.           plot_poly_3dfx(poly);
  934.         }
  935. }
  936.  
  937.  
  938. void MakePolygonList()
  939. {
  940.     int i,j;
  941.  
  942.     VertexTYPE *v0,*v1,*v2;
  943.  
  944.     j=0;
  945.     for(i=0;i<Object.NumOfPolygons;i++)
  946.     {
  947.         v0=&Object.Vertex[Object.Polygon[i].Vertex[0]];
  948.         v1=&Object.Vertex[Object.Polygon[i].Vertex[1]];
  949.         v2=&Object.Vertex[Object.Polygon[i].Vertex[2]];
  950.  
  951.         /* if expression results in a negative then polygon is visible
  952.         if( ((v1->sx - v0->sx) * (v2->sy - v0->sy) - (v1->sy - v0->sy) * (v2->sx - v0->sx)) < 0 )
  953.         {
  954.             PolygonOrderList[j++]=i;
  955.         }*/
  956.     PolygonOrderList[j++]=i; /* all polys visible */
  957.     }
  958.     NumOfSortedPolygons=j;
  959. }
  960.  
  961.  
  962.  
  963. void CalculateColor() 
  964. { 
  965.   int i; 
  966.   int color; 
  967.   double DotProduct,t1,t2; 
  968.  
  969.   for(i=0; i < Object.NumOfVertices; i++) 
  970.   { 
  971.     DotProduct= Object.Vertex[i].Nwx * LightSource.x; 
  972.     t1=   Object.Vertex[i].Nwy * LightSource.y; 
  973.     t2=   Object.Vertex[i].Nwz * LightSource.z; 
  974.     DotProduct += (t1 + t2); 
  975.     t1=DotProduct * 64.0 ; 
  976.     Object.Vertex[i].color = 80.0 + t1; 
  977.   } 
  978. } 
  979.  
  980.  
  981. void RotatePoints() 
  982. { 
  983.   int i; 
  984.   double nx,ny,nz,cosxangle,sinxangle, 
  985.          cosyangle,sinyangle,coszangle,sinzangle; 
  986.   double t1, t2, t3; 
  987.  
  988.  
  989.   /* get the sine and cosine angles to save time from table lookup*/ 
  990.   sinxangle=sine[xangle]; /* Pitch */ 
  991.   cosxangle=cosine[xangle]; 
  992.   sinyangle=sine[yangle];  /* Yaw */ 
  993.   cosyangle=cosine[yangle]; 
  994.   sinzangle=sine[zangle];  /* Roll */ 
  995.   coszangle=cosine[zangle]; 
  996.  
  997.   /* loop through all vertices in object*/ 
  998.   for(i=0;i<Object.NumOfVertices;i++) 
  999.   { 
  1000.     /* make a pointer to the current vertex*/ 
  1001.     VertexTYPE *vert=&Object.Vertex[i]; 
  1002.  
  1003.     /* rotate around the x-axis*/ 
  1004.  
  1005.   vert->wz= ((vert->oy-cy)*cosxangle)-((vert->oz-cz)*sinxangle); 
  1006.   vert->wy= ((vert->oy-cy)*sinxangle)+((vert->oz-cz)*cosxangle); 
  1007.   vert->wx=vert->ox-cx; 
  1008.   /*comment out above line and stick this one in to
  1009.   see just how good env. mapping can be :) 
  1010.   vert->wx=0.0-cx; */
  1011.  
  1012.   /* rotate around the y-axis */ 
  1013.   nx = (vert->wx*cosyangle)-(vert->wz*sinyangle); 
  1014.   nz = (vert->wx*sinyangle)+(vert->wz*cosyangle); 
  1015.   vert->wx=nx; 
  1016.   vert->wz=nz; 
  1017.  
  1018.   /* rotate around the z-axis*/ 
  1019.   nx = (vert->wx*coszangle)-(vert->wy*sinzangle); 
  1020.   ny = (vert->wx*sinzangle)+(vert->wy*coszangle); 
  1021.   vert->wx=nx; 
  1022.   vert->wy=ny; 
  1023.  
  1024.   /* project the 3-D coordinates to screen coordinates*/ 
  1025.  
  1026.  
  1027.   t3 = vert->wz+zpos;  
  1028.  
  1029.   if (t3<0.00 ) 
  1030.   { 
  1031.     vert->sx =(int)(((vert->wx+xpos)/t3)* /*256.0*/ 512.0)+320;
  1032.     vert->sy =220-(int)(((vert->wy+ypos)/t3)* /*256.0*/ 512.0); 
  1033.   } 
  1034.   else  
  1035.   { /* ooh negative z!*/ 
  1036.     t3 = -1.0; 
  1037.     t3 = -0.1; 
  1038.     t3 = 1.0+ t3;
  1039.     vert->sx =(int)(((vert->wx+xpos)*t3)*512.0)+320; 
  1040.     vert->sy =(int)(((vert->wy+ypos)*t3)*512.0)+220; 
  1041.   } 
  1042.   vert->sz=(int)(vert->wz+zpos); 
  1043.   vert->sz=(int)t3;
  1044.   
  1045.   } 
  1046. } 
  1047.  
  1048. /*--------------------------------------------------------------------------*/
  1049.  
  1050.  
  1051.  
  1052. /*--------------------------------------------------------------------*/ 
  1053.  
  1054. void DrawObject()
  1055. {
  1056.     int i;
  1057.  
  1058.     fprintf(fp,"make poly list\n");
  1059.     MakeCulledPolygonList();
  1060.     fprintf(fp,"sort poly list\n");
  1061.     SortPolygonList();
  1062.     fprintf(fp,"calc colour\n");
  1063.     CalculateColor();
  1064. /**/
  1065.     guAlphaSource( GR_ALPHASOURCE_ITERATED_ALPHA );
  1066.     grAlphaBlendFunction( GR_BLEND_SRC_ALPHA, 
  1067.                           GR_BLEND_ONE_MINUS_SRC_ALPHA, 
  1068.                           GR_BLEND_ONE, 
  1069.                           GR_BLEND_ZERO );
  1070.     grAlphaTestFunction( GR_CMP_ALWAYS );
  1071.  
  1072.     guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
  1073.     if (mode == MASK ) /* Turn face on here */
  1074.       guTexSource( facetexture );
  1075.     else
  1076.       guTexSource( *fgtexture );
  1077.     grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
  1078.     /**/
  1079.  
  1080.     for(i=0;i<NumOfSortedPolygons;i++)
  1081.     {
  1082.       if (mode != CMASK)
  1083.         plot_tri_3dfx(&Object.Polygon[PolygonOrderList[i]]);
  1084.       else
  1085.         plot_poly_3dfx(&Object.Polygon[PolygonOrderList[i]]);
  1086.     }
  1087.     
  1088. }
  1089.  
  1090. int
  1091. swapbuffer()
  1092. {
  1093.     while(grBufferNumPending());
  1094.      grBufferSwap(0);
  1095.     
  1096.      guColorCombineFunction( GR_COLORCOMBINE_ITRGB );
  1097.     /* Thi renders a background image */
  1098.     plot_bg();/**/
  1099.  
  1100.      /* Or use this to simply clear the screen - twice as fast o/
  1101.     grBufferClear( 0xFF223344, 0, GR_WDEPTHVALUE_FARTHEST );/**/
  1102. }
  1103.  
  1104.  
  1105.  
  1106.  
  1107. void
  1108. Random ()
  1109. {
  1110. int i,j;
  1111. int pindex;
  1112. int z;
  1113. double xf,yf,zf;
  1114.  
  1115.   Object.NumOfVertices = 0;
  1116.   for (i=0;i<MAXVERTICES;i++)
  1117.   {
  1118.     Object.Vertex[i].ox = 99999;
  1119.   }
  1120.  
  1121.   Object.NumOfVertices=0;
  1122.   for (i=0;i<WATER;i++)
  1123.   {
  1124.     for (j=0;j<WATER;j++)
  1125.     {
  1126.         z = 0;
  1127.         Object.Vertex[i+j*WATER].oy=(double)(i*2.5);
  1128.         Object.Vertex[i+j*WATER].oz=(double)(j*2.5);
  1129.         Object.Vertex[i+j*WATER].ox=(double)(z);
  1130.         Object.Vertex[i+j*WATER].s = (255.0/(double)WATER)*(double)j;
  1131.         Object.Vertex[i+j*WATER].t = (255.0/(double)WATER)*(double)i;
  1132.         Object.NumOfVertices++;
  1133.     }
  1134.  }
  1135.  
  1136.   printf("Object.NumOfVertices=%d\n",Object.NumOfVertices);
  1137.  
  1138.   pindex=0;
  1139.   for (i=1;i<WATER;i++)
  1140.   {
  1141.     for (j=1;j<WATER;j++)
  1142.     { /* Try is clockwise...*/
  1143.       Object.Polygon[pindex].Vertex[0] = (j-1)+(i-1)*WATER;
  1144.       Object.Polygon[pindex].Vertex[2] = (j)+(i)*WATER;
  1145.       Object.Polygon[pindex].Vertex[1] = (j)+(i-1)*WATER;
  1146.       Object.Polygon[pindex].Vertex[3] = 99999;
  1147.       Object.Polygon[pindex].NumOfVertices = 3;
  1148.       pindex++;
  1149.  
  1150.       Object.Polygon[pindex].Vertex[0] = (j-1)+(i-1)*WATER;
  1151.       Object.Polygon[pindex].Vertex[2] = (j-1)+(i)*WATER;
  1152.       Object.Polygon[pindex].Vertex[1] = (j)+(i)*WATER;
  1153.       Object.Polygon[pindex].Vertex[3] = 99999;
  1154.       Object.Polygon[pindex].NumOfVertices = 3;
  1155.       pindex++;
  1156.     }
  1157.   }
  1158.   Object.NumOfPolygons=pindex;
  1159.   printf("Object.NumOfPolygons=%d\n",Object.NumOfPolygons);
  1160.  
  1161.   xf=0.0;yf=0.0;zf=0.0;
  1162.   for (i=0;i<MAXVERTICES;i++)
  1163.   {
  1164.     if (Object.Vertex[i].ox==99999) break;
  1165.     xf = xf + (double) Object.Vertex[i].ox;
  1166.     yf = yf + (double) Object.Vertex[i].oy;
  1167.     zf = zf + (double) Object.Vertex[i].oz;
  1168.   }
  1169.   xf = xf / (double)i; yf = yf / (double)i; zf = zf / (double)i;
  1170.   printf("Average = %f %f %f\n",xf,yf,zf);
  1171.   for (i=0;i<MAXVERTICES;i++)
  1172.   {
  1173.     if (Object.Vertex[i].ox==99999) break;
  1174.     Object.Vertex[i].ox = Object.Vertex[i].ox - (int)xf;
  1175.     Object.Vertex[i].oy = Object.Vertex[i].oy - (int)yf;
  1176.     Object.Vertex[i].oz = Object.Vertex[i].oz - (int)zf;
  1177.   }
  1178.  
  1179. }
  1180.  
  1181. /*----------------------------------------------------------*/
  1182.  
  1183. /*----------------------------------------------------------*/ 
  1184.  
  1185. void ClearVertexList() 
  1186. { 
  1187.  
  1188. int i; 
  1189.  
  1190.   Object.NumOfVertices = 0; 
  1191.   for (i=0;i<MAXVERTICES;i++) 
  1192.   { 
  1193.     Object.Vertex[i].ox = 99999; 
  1194.   } 
  1195. } 
  1196.  
  1197.  
  1198. /*---------------------- draw gouraud polygon ------------------------------*/ 
  1199.  
  1200.  int
  1201. Load3dfxTexture(char *texfile, GrMipMapId_t *texture)
  1202. {
  1203.  
  1204. Gu3dfInfo         info;
  1205.  
  1206. /* Load Texture */
  1207.   if ( !gu3dfGetInfo( texfile, &info ) )  
  1208.   {
  1209.     fprintf(stderr, "ERROR: could not load %s\n",texfile);
  1210.     grGlideShutdown();
  1211.     exit( -1 );
  1212.   }
  1213.   else
  1214.   {
  1215.      info.data = malloc( info.mem_required );
  1216.  
  1217.      if ( info.data == 0 ) {
  1218.         fprintf( stderr, "out of memory for texture\n" );
  1219.         grGlideShutdown();
  1220.         exit( -1 );
  1221.      }
  1222.  
  1223.      if ( !gu3dfLoad(texfile, &info ) ) {
  1224.         fprintf( stderr, "could not load texture file\n" );
  1225.         grGlideShutdown();
  1226.         exit( -1 );
  1227.      }
  1228.  
  1229.      *texture = guTexAllocateMemory( 0, GR_MIPMAPLEVELMASK_BOTH,
  1230.                                   info.header.width, info.header.height,
  1231.                                   info.header.format,
  1232.                                   GR_MIPMAP_NEAREST,
  1233.                                   info.header.small_lod, info.header.large_lod,
  1234.                                   info.header.aspect_ratio,
  1235.                                   GR_TEXTURECLAMP_WRAP, GR_TEXTURECLAMP_WRAP,
  1236.                                   GR_TEXTUREFILTER_BILINEAR, GR_TEXTUREFILTER_BILINEAR,
  1237.                                   0.0F,
  1238.                                   FXFALSE );
  1239.      if ( *texture == GR_NULL_MIPMAP_HANDLE ) {
  1240.         fprintf( stderr, "could not allocate memory for lava.3df\n" );
  1241.         grGlideShutdown();
  1242.         exit( -1 );
  1243.      }
  1244.      guTexDownloadMipMap(*texture, info.data, &info.table.nccTable );
  1245.      free( info.data );
  1246.   }
  1247.   return(0);
  1248. }
  1249.  
  1250.  
  1251.  
  1252.  
  1253.  
  1254. void bench ()
  1255. {
  1256.      GrVertex vtx1, vtx2, vtx3;
  1257.      int i;
  1258.      clock_t tim;
  1259.  
  1260.       vtx1.x=100.f;      vtx1.y=100.f;
  1261.       vtx2.x=200.f;      vtx2.y=100.f;
  1262.       vtx3.x=150.f;      vtx3.y=150.f;
  1263.       vtx1.r=189.f;      vtx2.r=10.f;      vtx3.r=99.f;
  1264.       vtx1.g=2.f;      vtx2.g=255.f;      vtx3.g=77.f;
  1265.       vtx1.b=5.f;      vtx2.b=222.f;      vtx3.b=199.f;
  1266.       vtx1.a=220.0f;      vtx2.a=220.0f;      vtx3.a=220.0f;
  1267.  
  1268.       tim=clock();
  1269.  
  1270.       for (i=0;i<5000;i++)
  1271.         grDrawTriangle( &vtx1, &vtx2, &vtx3 );
  1272.     
  1273.       tim=clock()-tim;
  1274.       grBufferSwap(0);
  1275.  
  1276.       while(!kbhit());
  1277.  
  1278.       printf("Elapsed = %lf seconds\n",(double)(tim)/CLOCKS_PER_SEC);   
  1279.       printf("%f tris/sec\n",5000.0f/((double)(tim)/CLOCKS_PER_SEC));
  1280. }
  1281.  
  1282.  
  1283.  
  1284. void plot_bg()
  1285. {
  1286.     static int rot  = 0;
  1287.     double tx, ty;
  1288.  
  1289.     GrVertex vlist[4];
  1290.     rot = (rot++) % (MAXDEGREES-1);
  1291.     tx = sine[rot]*128.0;
  1292.     ty = cosine[rot]*128.0;
  1293.  
  1294.     vlist[0].x = 0.f;
  1295.     vlist[0].y = 0.f;
  1296.     vlist[0].r=128.0f;
  1297.     vlist[0].g=0.0f;
  1298.     vlist[0].b=0.0f;
  1299.     vlist[0].a=255.0f;
  1300.  
  1301.     vlist[1].x = 640.f;
  1302.     vlist[1].y = 0.f;
  1303.     vlist[1].r=200.0f;
  1304.     vlist[1].g=0.0f;
  1305.     vlist[1].b=0.0f;
  1306.     vlist[1].a=255.0f;
  1307.  
  1308.     vlist[2].x = 0.f;
  1309.     vlist[2].y = 480.f;
  1310.     vlist[2].r=55.0f;
  1311.     vlist[2].g=0.0f;
  1312.     vlist[2].b=0.0f;
  1313.     vlist[2].a=255.0f;
  1314.  
  1315.     vlist[3].x = 640.f;
  1316.     vlist[3].y = 480.f;
  1317.     vlist[3].r=100.0f;
  1318.     vlist[3].g=0.0f;
  1319.     vlist[3].b=0.0f;
  1320.     vlist[3].a=255.0f;
  1321.  
  1322.     vlist[0].oow=1.f/2000.0f;
  1323.     vlist[1].oow=1.f/2000.0f;
  1324.     vlist[2].oow=1.f/2000.0f;
  1325.     vlist[3].oow=1.f/2000.0f;
  1326.  
  1327.     vlist[0].tmuvtx[0].sow = (tx+128.0)   * vlist[0].oow; 
  1328.     vlist[0].tmuvtx[0].tow = (ty+128.0)   * vlist[0].oow;
  1329.  
  1330.     vlist[1].tmuvtx[0].sow = (128.0-ty)   * vlist[1].oow; 
  1331.     vlist[1].tmuvtx[0].tow = (tx+128.0) * vlist[1].oow;
  1332.  
  1333.     vlist[2].tmuvtx[0].sow = (ty+128.0)   * vlist[2].oow; 
  1334.     vlist[2].tmuvtx[0].tow = (128.0-tx)   * vlist[2].oow;
  1335.  
  1336.     vlist[3].tmuvtx[0].sow = (128.0-tx) * vlist[3].oow; 
  1337.     vlist[3].tmuvtx[0].tow = (128.0-ty) * vlist[3].oow;
  1338.  
  1339.  
  1340.     
  1341.     guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
  1342.     guTexSource( *bgtexture );
  1343.     grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
  1344.  
  1345.     /* hmm do bias bit .. */
  1346.     grDrawTriangle(&vlist[0],&vlist[1],&vlist[2]);
  1347.     grDrawTriangle(&vlist[1],&vlist[3],&vlist[2]);
  1348.     
  1349.     
  1350.     guColorCombineFunction( GR_COLORCOMBINE_ITRGB );
  1351. }
  1352.  
  1353.  
  1354.  
  1355. void plot_poly_3dfx (PolygonTYPE *poly)
  1356. {
  1357.      GrVertex vlist[255];
  1358.      GrState state;
  1359.      int i;
  1360.      float sow[4],tow[4];
  1361.      float s,t;
  1362.  
  1363.      sow[0] = 0.0f;tow[0]=0.0f;
  1364.      sow[1] = 255.0f;tow[1]=0.0f;
  1365.      sow[2] = 255.0f;tow[2]=255.0f;
  1366.      sow[3] = 0.0f;tow[3]=255.0f;
  1367.  
  1368.      for (i=0;i<poly->NumOfVertices;i++)
  1369.      {
  1370.       vlist[i].x=(float)Object.Vertex[poly->Vertex[i]].sx;
  1371.       vlist[i].y=(float)Object.Vertex[poly->Vertex[i]].sy;
  1372.  
  1373.       vlist[i].r=(float)Object.Vertex[poly->Vertex[i]].color;
  1374.       vlist[i].g=(float)Object.Vertex[poly->Vertex[i]].color*0.f;
  1375.       vlist[i].b=(float)Object.Vertex[poly->Vertex[i]].color*0.f;
  1376.  
  1377.       vlist[i].a=255.0f;
  1378.       /*vlist[i].a=(float)Object.Vertex[poly->Vertex[i]].color;*/
  1379.  
  1380.       vlist[i].oow = -1.f/(float)Object.Vertex[poly->Vertex[i]].sz;
  1381.       
  1382.  
  1383.         /*
  1384.       vlist[i].tmuvtx[0].sow = sow[i % 4]   * vlist[i].oow;
  1385.       vlist[i].tmuvtx[0].tow = tow[i % 4]   * vlist[i].oow;
  1386.       */
  1387.       
  1388.       Object.Vertex[poly->Vertex[i]].s = 127.0 +(127.0/20.0) *
  1389.           Object.Vertex[poly->Vertex[i]].wx; /* Adjust height wise */
  1390.  
  1391.       Object.Vertex[poly->Vertex[i]].t = 127.0 +(127.0/20.0) *
  1392.           -Object.Vertex[poly->Vertex[i]].wy; /* Adjust width wise */
  1393.       
  1394.  
  1395.  
  1396.       
  1397.       vlist[i].tmuvtx[0].sow =
  1398.   (Object.Vertex[poly->Vertex[i]].s - 40.0*Object.Vertex[poly->Vertex[i]].Nox)
  1399.                      * vlist[i].oow;
  1400.  
  1401.       vlist[i].tmuvtx[0].tow = 
  1402.   (Object.Vertex[poly->Vertex[i]].t - 40.0*Object.Vertex[poly->Vertex[i]].Noy)
  1403.                      * vlist[i].oow;
  1404. /*
  1405.       vlist[i].tmuvtx[0].sow =
  1406.   (Object.Vertex[poly->Vertex[i]].s + 40.0*
  1407.   (Object.Vertex[poly->Vertex[i]].SNox+Object.Vertex[poly->Vertex[i]].Nox))
  1408.                      * vlist[i].oow;
  1409.  
  1410.       vlist[i].tmuvtx[0].tow = 
  1411.   (Object.Vertex[poly->Vertex[i]].t + 40.0*
  1412.   (Object.Vertex[poly->Vertex[i]].SNoy+Object.Vertex[poly->Vertex[i]].Noy))
  1413.                      * vlist[i].oow;*/
  1414.  
  1415. /*
  1416.       vlist[i].tmuvtx[0].sow = (Object.Vertex[poly->Vertex[i]].s) * vlist[i].oow;
  1417.       vlist[i].tmuvtx[0].tow = (Object.Vertex[poly->Vertex[i]].t) * vlist[i].oow;
  1418. */
  1419.       
  1420.       if (vlist[i].x > 640 ||
  1421.           vlist[i].x <0    ||
  1422.           vlist[i].y >480  ||
  1423.           vlist[i].y <0 ) return;
  1424.       
  1425.      }
  1426. #ifdef GO
  1427.     grDrawPlanarPolygonVertexList(poly->NumOfVertices,vlist);
  1428.     /*guColorCombineFunction( GR_COLORCOMBINE_ITRGB );*/
  1429. #endif
  1430.  
  1431.     /* save state! */
  1432.     grGlideGetState(&state);
  1433.  
  1434.     /* projected textrure :( */
  1435.  
  1436.      for (i=0;i<poly->NumOfVertices;i++)
  1437.      {
  1438.       s = (20.0f * vlist[i].oow)*(vlist[i].x - 320.0f) ;
  1439.       t = (20.0f * vlist[i].oow)*(240.0f - vlist[i].y) ;
  1440.       s = (s+320.0f)/2.5098f;
  1441.       t = (t+240.0f)/1.8824f;
  1442.  
  1443.       vlist[i].tmuvtx[0].sow = s   * vlist[i].oow;
  1444.       vlist[i].tmuvtx[0].tow = t   * vlist[i].oow;
  1445.       vlist[i].tmuvtx[0].oow = 20.0f * vlist[i].oow;
  1446.     }
  1447. #ifdef GO
  1448.     guColorCombineFunction(GR_COLORCOMBINE_DECAL_TEXTURE);
  1449.     grAlphaBlendFunction(GR_BLEND_ONE,GR_BLEND_ONE,
  1450.                          GR_BLEND_ONE,GR_BLEND_ZERO);
  1451.  
  1452.     guTexSource( spotlight);
  1453.     grTexCombineFunction(GR_TMU0, GR_TEXTURECOMBINE_DECAL);
  1454.     grDrawPlanarPolygonVertexList(poly->NumOfVertices,vlist);
  1455.     
  1456. #endif
  1457.     /* restore state */
  1458.     grGlideSetState(&state);
  1459. }
  1460.  
  1461. /*???*/
  1462. void plot_tri_3dfx (PolygonTYPE *poly)
  1463. {
  1464.      GrVertex vtx1, vtx2, vtx3;
  1465.      GrState state ;
  1466.      float s,t;
  1467.      long tmp;
  1468.  
  1469.       vtx1.x=(float)Object.Vertex[poly->Vertex[0]].sx;
  1470.       vtx1.y=(float)Object.Vertex[poly->Vertex[0]].sy;
  1471.  
  1472.       vtx2.x=(float)Object.Vertex[poly->Vertex[1]].sx;
  1473.       vtx2.y=(float)Object.Vertex[poly->Vertex[1]].sy;
  1474.  
  1475.       vtx3.x=(float)Object.Vertex[poly->Vertex[2]].sx;
  1476.       vtx3.y=(float)Object.Vertex[poly->Vertex[2]].sy;
  1477.  
  1478. vtx1.r=(float)Object.Vertex[poly->Vertex[0]].ox*20.0+128.0;
  1479. vtx2.r=(float)Object.Vertex[poly->Vertex[1]].ox*20.0+128.0;
  1480. vtx3.r=(float)Object.Vertex[poly->Vertex[2]].ox*20.0+128.0;
  1481.  
  1482. vtx1.g=(float)Object.Vertex[poly->Vertex[0]].ox*20.0+128.0;
  1483. vtx2.g=(float)Object.Vertex[poly->Vertex[1]].ox*20.0+128.0;
  1484. vtx3.g=(float)Object.Vertex[poly->Vertex[2]].ox*20.0+128.0;
  1485.  
  1486. vtx1.b=(float)Object.Vertex[poly->Vertex[0]].ox*20.0+128.0;
  1487. vtx2.b=(float)Object.Vertex[poly->Vertex[1]].ox*20.0+128.0;
  1488. vtx3.b=(float)Object.Vertex[poly->Vertex[2]].ox*20.0+128.0;
  1489.  
  1490.  
  1491. /*  SNAP */
  1492. tmp = vtx1.x * 16;    // increase by 4 bits, truncate off the rest
  1493. vtx1.x = tmp / 16.0;    // remove extra 4 bits, convert back to float
  1494. tmp = vtx1.y * 16;    // increase by 4 bits, truncate off the rest
  1495. vtx1.y = tmp / 16.0;    // remove extra 4 bits, convert back to float
  1496.  
  1497. tmp = vtx2.x * 16;    // increase by 4 bits, truncate off the rest
  1498. vtx2.x = tmp / 16.0;    // remove extra 4 bits, convert back to float
  1499. tmp = vtx2.y * 16;    // increase by 4 bits, truncate off the rest
  1500. vtx2.y = tmp / 16.0;    // remove extra 4 bits, convert back to float
  1501.  
  1502. tmp = vtx3.x * 16;    // increase by 4 bits, truncate off the rest
  1503. vtx3.x = tmp / 16.0;    // remove extra 4 bits, convert back to float
  1504. tmp = vtx3.y * 16;    // increase by 4 bits, truncate off the rest
  1505. vtx3.y = tmp / 16.0;    // remove extra 4 bits, convert back to float
  1506.  
  1507.  
  1508. /*o/  vtx1.a=220.0f;
  1509.       vtx2.a=220.0f;
  1510.       vtx3.a=220.0f;/**/
  1511.  
  1512. /**/  vtx1.a=255.0f;
  1513.       vtx2.a=255.0f;
  1514.       vtx3.a=255.0f;/**/
  1515.  
  1516.       /* Make the alpha value (transparency) equal to the
  1517.          colour at each vertex - the brighter it is, the
  1518.          less transparent it is. Gives a nice 'glare' effect */
  1519.  
  1520. /*      vtx1.a=(float)Object.Vertex[poly->Vertex[0]].color;
  1521.       vtx2.a=(float)Object.Vertex[poly->Vertex[1]].color;
  1522.       vtx3.a=(float)Object.Vertex[poly->Vertex[2]].color;/**/
  1523.  
  1524.       vtx1.oow = -1.f/(float)Object.Vertex[poly->Vertex[0]].sz;
  1525.       vtx2.oow = -1.f/(float)Object.Vertex[poly->Vertex[1]].sz;
  1526.       vtx3.oow = -1.f/(float)Object.Vertex[poly->Vertex[2]].sz;
  1527.  
  1528.  
  1529.       
  1530. /*if (vtx1.x<-50.0|| vtx1.y <-50.0 || 
  1531.     vtx1.x >690.0 || vtx1.y >520.0||
  1532.   vtx2.x <-50.0 || vtx2.y <-50.0 ||
  1533.   vtx2.x >690.0 || vtx2.y >530.0||
  1534.   vtx3.x <-50.0 || vtx3.y <-50.0 || 
  1535.   vtx3.x >690.0 || vtx3.y >530.0||*/
  1536. /*
  1537.  if ( vtx1.oow <0.0 || vtx2.oow <0.0 || vtx3.oow <0.0)
  1538.         return;*/
  1539.         
  1540.       /*if (vtx1.oow <0.0 || vtx2.oow <0.0 || vtx3.oow <0.0)
  1541.           return;*/
  1542.  
  1543.       if (vtx1.oow <0.0) vtx1.oow = 0.9999;
  1544.       if (vtx2.oow <0.0) vtx2.oow = 0.9999;
  1545.       if (vtx3.oow <0.0) vtx3.oow = 0.9999;/**/
  1546.     
  1547.       /**/
  1548.       if (vtx1.x<1.0) vtx1.x = 1.0;
  1549.       if (vtx1.x>640.0) vtx1.x = 640.0;
  1550.       if (vtx1.y<1.0) vtx1.y =  1.0;
  1551.       if (vtx1.y>480.0) vtx1.y = 480.0;
  1552.  
  1553.       if (vtx2.x<1.0) vtx2.x = 1.0;
  1554.       if (vtx2.x>640.0) vtx2.x = 640.0;
  1555.       if (vtx2.y<1.0) vtx2.y = 1.0;
  1556.       if (vtx2.y>480.0) vtx2.y = 480.0;
  1557.  
  1558.       if (vtx3.x<1.0) vtx3.x =  1.0;
  1559.       if (vtx3.x>640.0) vtx3.x = 640.0;
  1560.       if (vtx3.y<1.0) vtx3.y = 1.0;
  1561.       if (vtx3.y>480.0) vtx3.y = 480.0;/**/
  1562. /*
  1563.       vtx1.tmuvtx[0].sow = 0.f   * vtx1.oow;
  1564.       vtx1.tmuvtx[0].tow = 0.f   * vtx1.oow;
  1565.       vtx2.tmuvtx[0].sow = 255.f * vtx2.oow;
  1566.       vtx2.tmuvtx[0].tow = 255.f * vtx2.oow;
  1567.       vtx3.tmuvtx[0].sow = 255.f * vtx3.oow;
  1568.       vtx3.tmuvtx[0].tow = 0.f   * vtx3.oow;
  1569. */
  1570.  
  1571. if (mode == SURFACE)
  1572. {
  1573. vtx1.tmuvtx[0].sow =
  1574.  (Object.Vertex[poly->Vertex[0]].s + 100.0*Object.Vertex[poly->Vertex[0]].Noz)
  1575.                      * vtx1.oow;
  1576. vtx1.tmuvtx[0].tow = 
  1577.   (Object.Vertex[poly->Vertex[0]].t + 100.0*Object.Vertex[poly->Vertex[0]].Noy)
  1578.                      * vtx1.oow;
  1579. vtx2.tmuvtx[0].sow =
  1580.   (Object.Vertex[poly->Vertex[1]].s + 100.0*Object.Vertex[poly->Vertex[1]].Noz)
  1581.                      * vtx2.oow;
  1582. vtx2.tmuvtx[0].tow = 
  1583.   (Object.Vertex[poly->Vertex[1]].t + 100.0*Object.Vertex[poly->Vertex[1]].Noy)
  1584.                      * vtx2.oow;
  1585. vtx3.tmuvtx[0].sow = 
  1586.   (Object.Vertex[poly->Vertex[2]].s + 100.0*Object.Vertex[poly->Vertex[2]].Noz)
  1587.                       * vtx3.oow;
  1588. vtx3.tmuvtx[0].tow = 
  1589.   (Object.Vertex[poly->Vertex[2]].t + 100.0*Object.Vertex[poly->Vertex[2]].Noy)
  1590.                      * vtx3.oow;
  1591. }
  1592. else if (mode == BLOB)/* BLOB */
  1593. {
  1594. vtx1.tmuvtx[0].sow =
  1595.   (Object.Vertex[poly->Vertex[0]].s + 100.00*
  1596.   (Object.Vertex[poly->Vertex[0]].SNox-Object.Vertex[poly->Vertex[0]].Nox))
  1597.                      * vtx1.oow;
  1598. vtx1.tmuvtx[0].tow = 
  1599.   (Object.Vertex[poly->Vertex[0]].t + 100.0*
  1600.   (Object.Vertex[poly->Vertex[0]].SNoy-Object.Vertex[poly->Vertex[0]].Noy))
  1601.                      * vtx1.oow;
  1602. vtx2.tmuvtx[0].sow =
  1603.   (Object.Vertex[poly->Vertex[1]].s + 100.0*
  1604.   (Object.Vertex[poly->Vertex[1]].SNox-Object.Vertex[poly->Vertex[1]].Nox))
  1605.                      * vtx2.oow;
  1606. vtx2.tmuvtx[0].tow = 
  1607.   (Object.Vertex[poly->Vertex[1]].t + 100.0*
  1608.   (Object.Vertex[poly->Vertex[1]].SNoy-Object.Vertex[poly->Vertex[1]].Noy))
  1609.                      * vtx2.oow;
  1610. vtx3.tmuvtx[0].sow = 
  1611.   (Object.Vertex[poly->Vertex[2]].s + 100.0*
  1612.   (Object.Vertex[poly->Vertex[2]].SNox-Object.Vertex[poly->Vertex[2]].Nox))
  1613.                       * vtx3.oow;
  1614. vtx3.tmuvtx[0].tow = 
  1615.   (Object.Vertex[poly->Vertex[2]].t + 100.0*
  1616.   (Object.Vertex[poly->Vertex[2]].SNoy-Object.Vertex[poly->Vertex[2]].Noy))
  1617.                      * vtx3.oow;
  1618. }
  1619. else
  1620. {
  1621.   vtx1.tmuvtx[0].sow = (Object.Vertex[poly->Vertex[0]].s) * vtx1.oow;
  1622.   vtx1.tmuvtx[0].tow = (Object.Vertex[poly->Vertex[0]].t) * vtx1.oow;
  1623.   vtx2.tmuvtx[0].sow = (Object.Vertex[poly->Vertex[1]].s) * vtx2.oow;
  1624.   vtx2.tmuvtx[0].tow = (Object.Vertex[poly->Vertex[1]].t) * vtx2.oow;
  1625.   vtx3.tmuvtx[0].sow = (Object.Vertex[poly->Vertex[2]].s) * vtx3.oow;
  1626.   vtx3.tmuvtx[0].tow = (Object.Vertex[poly->Vertex[2]].t) * vtx3.oow;
  1627. }
  1628.  
  1629. /*if (Object.Vertex[poly->Vertex[2]].Noy != 0.0)
  1630. printf("nx ny nz %f %f %f\n",
  1631.        Object.Vertex[poly->Vertex[2]].Nox,
  1632.        Object.Vertex[poly->Vertex[2]].Noy,
  1633.        Object.Vertex[poly->Vertex[2]].Noz);*/
  1634. #ifdef GO
  1635.     /*guDrawTriangleWithClip( &vtx1, &vtx2, &vtx3 );*/
  1636.      grDrawTriangle( &vtx1, &vtx2, &vtx3 );
  1637. #endif
  1638.  
  1639. return;
  1640.  
  1641.     /* save state! Very inefficient way of doing this
  1642.        should readly draw all basic texture polys first 
  1643.        and then draw them all using prjected texture
  1644.        mapping. But I don't care :) */
  1645.  
  1646.     grGlideGetState(&state);
  1647.  
  1648.     
  1649.       /* My head hurts :( */
  1650. #ifdef GO
  1651.     guColorCombineFunction(GR_COLORCOMBINE_ITRGB );
  1652.     
  1653.     grAlphaCombine(GR_COMBINE_FUNCTION_BLEND_OTHER,GR_COMBINE_FACTOR_ONE,
  1654.                    GR_COMBINE_LOCAL_NONE,GR_COMBINE_OTHER_CONSTANT,
  1655.                    FXFALSE);
  1656.  
  1657.  
  1658.     grAlphaBlendFunction(GR_BLEND_ONE,GR_BLEND_ONE,
  1659.                          GR_BLEND_ONE,GR_BLEND_ZERO);
  1660.  
  1661.     grAlphaTestFunction( GR_CMP_ALWAYS );
  1662.     grDrawTriangle( &vtx1, &vtx2, &vtx3 );
  1663. #endif
  1664.     
  1665.     /* restore state */
  1666.     grGlideSetState(&state);
  1667. }
  1668.  
  1669.  
  1670.  
  1671.  
  1672.  
  1673.  
  1674.  
  1675. /*---------------------------------------------------------------*/ 
  1676.  
  1677. int _cdecl main(int argc,char**argv) 
  1678. { 
  1679. int x,y; 
  1680. int index=0; 
  1681.  
  1682.   system("del out\n");
  1683.   fp=fopen("listval.txt","w");
  1684.   setbuf(fp,0);
  1685.  
  1686.  
  1687.   build_table();
  1688.   build_itable();
  1689.  
  1690.   /* set up Glide and the hardware  */
  1691.   screenRes = GR_RESOLUTION_640x480;
  1692.   grSstQueryBoards(&hwconfig);
  1693.   fprintf(stdout,"Number of boards = %d\n",hwconfig.num_sst);
  1694.   fflush(stdout);
  1695.  
  1696.   grGlideInit();
  1697.   if ( !grSstQueryHardware( &hwconfig ) )
  1698.   {
  1699.     fprintf( stderr, "main: grSstQueryHardware failed!\n" );
  1700.     grGlideShutdown();
  1701.     exit( -1 );
  1702.   }
  1703.  
  1704.   grSstSelect( 0 );
  1705.   if ( !grSstOpen( screenRes,
  1706.                    GR_REFRESH_75Hz,
  1707.                    GR_COLORFORMAT_ARGB,
  1708.                    GR_ORIGIN_LOWER_LEFT,
  1709.                    GR_SMOOTHING_ENABLE,
  1710.                    2 ) )
  1711.   {
  1712.     fprintf( stderr, "main: grSstOpen failed!\n" );
  1713.     grGlideShutdown();
  1714.     exit( -1 );
  1715.   }
  1716.  
  1717.     printf("Gouraud Shaded Vectors 2\n");
  1718.     strcpy(filename,"diamond.v10");
  1719.  
  1720.     max = 99999;
  1721.  
  1722.     if (argc>1)  max = atoi(argv[1]);
  1723.  
  1724.     printf("max=%d\n",max);
  1725.     
  1726.     guColorCombineFunction( GR_COLORCOMBINE_ITRGB );
  1727.  
  1728.     guAlphaSource( GR_ALPHASOURCE_ITERATED_ALPHA );
  1729.     grAlphaBlendFunction( GR_BLEND_SRC_ALPHA, 
  1730.                           GR_BLEND_ONE_MINUS_SRC_ALPHA, 
  1731.                           GR_BLEND_ONE, 
  1732.                           GR_BLEND_ZERO );
  1733.     grAlphaTestFunction( GR_CMP_ALWAYS );
  1734.  
  1735.     /*bench(); /* noddy benchmark procedure  - ignore 
  1736.     grBufferClear( 0x000000, 0, GR_WDEPTHVALUE_FARTHEST );
  1737.     grBufferSwap(0);
  1738.     grBufferClear( 0x000000, 0, GR_WDEPTHVALUE_FARTHEST );*/
  1739.  
  1740. /* 
  1741.    image0 - dots
  1742.    image1 - 
  1743.    image2 - BW 
  1744.    image3 - 
  1745.    image4 - dunes 
  1746.    image5 moon
  1747.  */
  1748.     /* Texture for CHROME surface */
  1749.     Load3dfxTexture("image0.3df",&texture1);
  1750.     Load3dfxTexture("image1.3df",&texture2);
  1751.     Load3dfxTexture("image2.3df",&texture3);
  1752.     Load3dfxTexture("image3.3df",&texture4);
  1753.     Load3dfxTexture("image4.3df",&texture5);
  1754.     Load3dfxTexture("image5.3df",&texture6);
  1755.     
  1756.     /* point object and background textures at some defaults */
  1757.     fgtexture = &texture4;
  1758.     bgtexture = &texture4;
  1759.  
  1760.     /* Texture for MASK surface */
  1761.     Load3dfxTexture("facehi.3df",&facetexture);
  1762.  
  1763.     Load3dfxTexture("spot.3df",&spotlight);
  1764.  
  1765.     Demo();
  1766.     grGlideShutdown();
  1767.     return(0);
  1768. }
  1769.  
  1770.  
  1771. void
  1772. ChangeTextures ()
  1773. {
  1774.     switch(rand()%6)
  1775.     {
  1776.     case 0:
  1777.         fgtexture = &texture1;
  1778.         break;
  1779.     case 1:
  1780.         fgtexture = &texture2;
  1781.         break;
  1782.     case 2:
  1783.         fgtexture = &texture3;
  1784.         break;
  1785.     case 3:
  1786.         fgtexture = &texture4;
  1787.         break;
  1788.      case 4:
  1789.          fgtexture = &texture5;
  1790.         break;
  1791.     case 5:
  1792.         fgtexture = &texture6;
  1793.         break;
  1794.     default:;
  1795.     }
  1796.  
  1797.   bgtexture = fgtexture;
  1798.  
  1799. }
  1800.     
  1801.  
  1802.  
  1803.  
  1804. void Demo(void) 
  1805. { 
  1806.   int i; 
  1807.   int frames = 0;
  1808.   int count=0; 
  1809.   int next;
  1810.   long int tim; 
  1811.   double vel = 4.0; 
  1812.   int level = 1;
  1813.   
  1814.   mode = SURFACE ;
  1815.   
  1816.   ClearVertexList(); 
  1817.   Random();
  1818.  
  1819.   srand( (unsigned)time( NULL ) );
  1820.  
  1821.   init();
  1822.  
  1823.   printf("init norms\n"); 
  1824.   
  1825.   InitNormals();
  1826.   FInitNormals(); 
  1827.  
  1828.   /* initialize a few things*/ 
  1829.   printf("initialize a few things\n"); 
  1830.   InitYTable(); 
  1831.   InitTrigTables(); 
  1832.   InitLightSource(); 
  1833.  
  1834.   /* initialize angle and position of object*/ 
  1835.   xangle=0; yangle=80/*64*/; zangle=256; 
  1836.   zpos=-1024.0; 
  1837.   zpos=-512.0; 
  1838.   zpos=-10.25; 
  1839.  
  1840.   cx = 31 ; cy = 20; cz = 0; 
  1841.  
  1842.   /* draw first frame so that globe won't "pop out of nowhere" (:*/ 
  1843.   MakeViewPolygonList(); 
  1844.  
  1845.   RotatePoints(); 
  1846.   RotateNormals(); 
  1847.   DrawObject(); 
  1848.  
  1849.   tim=clock(); 
  1850.   next = 200;
  1851.   /*mode = CMASK;DoFace();yangle=0;cx=0;*/
  1852.   /*if (rand()%2) mode = MASK;*/
  1853.   /*mode = BLOB; DoSphere(5);*/
  1854.   do 
  1855.   { 
  1856.       if (mode == SURFACE || mode == BLOB)
  1857.          calcFc (mode); 
  1858.  
  1859.       MakeViewPolygonList();
  1860.       
  1861.       RotatePoints();
  1862.       
  1863.       FInitNormals();
  1864.      
  1865.       if (mode == MASK)
  1866.           RotateNormals; /* copy out for chrome face */
  1867.     
  1868.       DrawObject();
  1869.       swapbuffer();
  1870.  
  1871.       xangle++; xangle = xangle % MAXDEGREES; 
  1872.       cy = cosine[(MAXDEGREES-xangle)%MAXDEGREES] * 60;
  1873.       cz =   sine[(MAXDEGREES-xangle)%MAXDEGREES] * 60;
  1874.       frames++;
  1875.  
  1876. /**/
  1877.       if (frames % (mode==CMASK?800:1200)==0) 
  1878.       {
  1879.         init ();
  1880.         if (mode == SURFACE)
  1881.         {
  1882.           ChangeTextures();
  1883.           mode = BLOB;
  1884.           DoSphere(4+rand()%1);
  1885.         }
  1886.         else if (mode == BLOB)
  1887.         { 
  1888.           ChangeTextures();
  1889.           yangle=0;cx=0;
  1890.              DoFace();
  1891.           mode = CMASK;
  1892.           if (rand()%8 == 0) mode = MASK;
  1893.         }
  1894.         else
  1895.         {
  1896.           ChangeTextures();
  1897.           yangle=80;cx=31;
  1898.           mode = SURFACE;
  1899.           Random();
  1900.         }
  1901.       }
  1902. /**/
  1903.  
  1904.       if (frames % next == 0)
  1905.       {
  1906.         V[rand()%WATER][rand()%WATER] = rand()%7+8;
  1907.         next = rand()%14;
  1908.         next = next*next+100;
  1909.  
  1910.         Vb[rand()%Object.NumOfVertices] = rand()%7;
  1911.       }
  1912.   } while(frames < max && !kbhit()); 
  1913.  
  1914.   tim=clock()-tim; 
  1915.   printf("Elapsed = %lf seconds\n",(double)(tim)/CLOCKS_PER_SEC);
  1916.   printf("FPS     = %lf \n",(double)frames/
  1917.                             ((double)(tim)/CLOCKS_PER_SEC));
  1918. } 
  1919.  
  1920. int
  1921. sleep(int x)
  1922. {
  1923.     long int tim;
  1924.     tim = clock();
  1925.  
  1926.     while (clock() < tim+x) ;
  1927.     return(0);
  1928. }
  1929.  
  1930.  
  1931. void MakeCulledPolygonList() 
  1932. { 
  1933.   int i,j; 
  1934.  
  1935.   VertexTYPE *v0,*v1,*v2; 
  1936.  
  1937.   j=0; 
  1938.   for(i=0;i<NumOfViewedPolygons;i++) 
  1939.   { 
  1940.     v0=&Object.Vertex[Object.Polygon[PolygonViewList[i]].Vertex[0]]; 
  1941.     v1=&Object.Vertex[Object.Polygon[PolygonViewList[i]].Vertex[1]]; 
  1942.     v2=&Object.Vertex[Object.Polygon[PolygonViewList[i]].Vertex[2]]; 
  1943.  
  1944.     /* if expression results in a negative then polygon is visible*/ 
  1945.     if( ((v1->sx-v0->sx) * (v2->sy-v0->sy) - (v1->sy - v0->sy)  
  1946.         *(v2->sx-v0->sx)) > 0 || mode == MASK || mode == CMASK) 
  1947.     { 
  1948.       PolygonOrderList[j++]  =PolygonViewList[i]; 
  1949.     } 
  1950.   } 
  1951.   NumOfSortedPolygons=j; 
  1952. } 
  1953.  
  1954.  
  1955.  
  1956. void SortPolygonList() 
  1957. { 
  1958.   int i,j; 
  1959.   int maxz,minz; 
  1960.   PolygonTYPE *poly; 
  1961.  
  1962.   /* first find the distance of each polygon (from midpoint of max & min z's)*/ 
  1963.   for(i=0;i<Object.NumOfPolygons;i++) 
  1964.   { 
  1965.  
  1966.     poly=&Object.Polygon[i]; 
  1967.     minz=65535; 
  1968.     maxz=-65536; 
  1969.     for(j=0;j<poly->NumOfVertices;j++) 
  1970.     { 
  1971.       if(Object.Vertex[poly->Vertex[j]].sz < minz) 
  1972.       { 
  1973.         minz=Object.Vertex[poly->Vertex[j]].sz; 
  1974.       } 
  1975.       if(Object.Vertex[poly->Vertex[j]].sz > maxz) 
  1976.       { 
  1977.         maxz=Object.Vertex[poly->Vertex[j]].sz; 
  1978.       } 
  1979.     } 
  1980.     /* now calculate the distance*/ 
  1981.     poly->zcenter=(maxz+minz)<<1; 
  1982.   } 
  1983.  
  1984.   /* qsort the polygons*/ 
  1985.   qsort(PolygonOrderList,NumOfSortedPolygons,sizeof(int),ComparePolygons); 
  1986.   /* all done the sorting process*/ 
  1987. } 
  1988.  
  1989.  
  1990. int _cdecl ComparePolygons(const void *a, const void *b) 
  1991. { 
  1992.   if( Object.Polygon[*(int *)a].zcenter < Object.Polygon[*(int *)b].zcenter ) 
  1993.   { 
  1994.     return -1; 
  1995.   } 
  1996.   else if( Object.Polygon[*(int *)a].zcenter >  
  1997.            Object.Polygon[*(int *)b].zcenter ) 
  1998.   { 
  1999.     return +1; 
  2000.   } 
  2001.   else 
  2002.   { 
  2003.     return 0; 
  2004.   } 
  2005. } 
  2006.  
  2007. /*-------------------------- inilialize light source -----------------------*/ 
  2008.  
  2009. void InitLightSource(void) 
  2010. { 
  2011.   double xlen,ylen,zlen,length; 
  2012.  
  2013.   /* assign the delault light source position*/ 
  2014.   xlen=-10; ylen=-10; zlen=-10; 
  2015.  
  2016.   /* calculate the length of the vector (light source to 0,0,0)*/ 
  2017.   length = sqrt(xlen*xlen + ylen*ylen + zlen*zlen); 
  2018.  
  2019.   /* scale it to a unit vector*/ 
  2020.   LightSource.x = (xlen/length); 
  2021.   LightSource.y = (ylen/length); 
  2022.   LightSource.z = (zlen/length); 
  2023. } 
  2024.  
  2025. /*==========================================================*/ 
  2026.   
  2027.  
  2028.  
  2029.  
  2030. int 
  2031. Visible(double tx, double ty) 
  2032. { 
  2033.   if (lsign*(axl*tx-byl*ty-cl) > 0.0  && 
  2034.       rsign*(axr*tx-byr*ty-cr) < 0.0) 
  2035.     return(1); 
  2036.   else 
  2037.     return(0); 
  2038. } 
  2039.  
  2040.  
  2041.  
  2042. int qabs(int x) 
  2043. { 
  2044. int copy  = x >>31; 
  2045. x ^= copy; 
  2046. return x-copy; 
  2047. } 
  2048.  
  2049.  
  2050.  
  2051.  
  2052. void MakeViewPolygonList()
  2053. {
  2054.   int i,j;
  2055.   VertexTYPE *v0,*v1,*v2;
  2056.  
  2057.   theta = (256+512+xangle)%MAXDEGREES;
  2058.   CalcViewTriangle(cz,cy,theta);
  2059.  
  2060.   j=0; 
  2061.   for(i=0;i<Object.NumOfPolygons;i++)
  2062.   {
  2063.     v0=&Object.Vertex[Object.Polygon[i].Vertex[0]];
  2064.     v1=&Object.Vertex[Object.Polygon[i].Vertex[1]];
  2065.     v2=&Object.Vertex[Object.Polygon[i].Vertex[2]];
  2066.  
  2067.     if ((lsign*(axl*v1->oz-byl*v1->oy-cl) > 0.0  &&
  2068.          rsign*(axr*v1->oz-byr*v1->oy-cr) < 0.0) ||
  2069.         (lsign*(axl*v2->oz-byl*v2->oy-cl) > 0.0  &&
  2070.          rsign*(axr*v2->oz-byr*v2->oy-cr) < 0.0) ||
  2071.         (lsign*(axl*v0->oz-byl*v0->oy-cl) > 0.0  &&
  2072.          rsign*(axr*v0->oz-byr*v0->oy-cr) < 0.0))
  2073.       PolygonViewList[j++]=i;
  2074.  
  2075.     if ((lsign*(axl*v1->oz-byl*v1->oy-cl) < 0.0 ||
  2076.          lsign*(axl*v2->oz-byl*v2->oy-cl) < 0.0 ||
  2077.          lsign*(axl*v0->oz-byl*v0->oy-cl) < 0.0 ) &&
  2078.         (rsign*(axr*v1->oz-byr*v1->oy-cr) > 0.0 ||
  2079.          rsign*(axr*v2->oz-byr*v2->oy-cr) > 0.0 ||
  2080.          rsign*(axr*v0->oz-byr*v0->oy-cr) > 0.0 ) &&
  2081.         (fsign*(axf*v1->oz-byf*v1->oy-cf) < 0.0 ||
  2082.          fsign*(axf*v2->oz-byf*v2->oy-cf) < 0.0 ||
  2083.          fsign*(axf*v0->oz-byf*v0->oy-cf) < 0.0 ))
  2084.     {
  2085.       PolygonViewList[j++]=i;
  2086.     }
  2087.  
  2088.     /*
  2089.     if (fsign*(axf*v1->oz-byf*v1->oy-cf) < 0.0 ||
  2090.         fsign*(axf*v2->oz-byf*v2->oy-cf) < 0.0 ||
  2091.         fsign*(axf*v0->oz-byf*v0->oy-cf) < 0.0 )
  2092.     {
  2093.       PolygonViewList[j++]=i;
  2094.       printf("FRONT\n");
  2095.     }*/
  2096.           
  2097.   }
  2098.   NumOfViewedPolygons=j;
  2099. }
  2100.  
  2101.  
  2102. void
  2103. CalcViewTriangle(double cx, double cy, int theta)
  2104. {
  2105.   /* hmm step back a bit...
  2106.   double mcx,mcy;
  2107.   cx = -10.5*dcosine[theta]+cx;
  2108.   cy = -10.5*dsine[theta]+cy; */
  2109.  
  2110.   /* Set up left and right view edges */
  2111.   rtheta = (theta+(MAXDEGREES-FOV))%MAXDEGREES;
  2112.   ltheta = (theta+FOV)%MAXDEGREES;
  2113.   ftheta = (theta+(MAXDEGREES/4))%MAXDEGREES;
  2114.  
  2115.   /* Line Equation = */
  2116.   if (qabs(256-ltheta)>128 &&  /* nearer x-axis */
  2117.       qabs(768-ltheta)>128)
  2118.   {
  2119.     axl = polar_lut[ltheta]; byl = 1.0; cl  = (cx*axl-cy);
  2120.   }
  2121.   else
  2122.   {
  2123.     axl= 1.0; byl = polar_lut[ltheta]; cl  = (cx - cy*byl);
  2124.   }
  2125.  
  2126.   if (qabs(256-rtheta)>128 &&  /* nearer x-axis */
  2127.       qabs(768-rtheta)>128)
  2128.   {
  2129.     axr = polar_lut[rtheta]; byr = 1.0; cr  = (cx*axr-cy);
  2130.   }
  2131.   else
  2132.   {
  2133.     axr = 1.0; byr = polar_lut[rtheta]; cr  = (cx - cy*byr);
  2134.   }
  2135.  
  2136.   if (qabs(256-ftheta)>128 &&  /* nearer x-axis */
  2137.       qabs(768-ftheta)>128)
  2138.   {
  2139.     axf = polar_lut[ftheta]; byf = 1.0; cf  = (cx*axf-cy);
  2140.   }
  2141.   else
  2142.   {
  2143.     axf = 1.0; byf = polar_lut[ftheta]; cf  = (cx - cy*byf);
  2144.   }
  2145.  
  2146.   tpx = 10.0*dcosine[theta]+cx;
  2147.   tpy = 10.0*dsine[theta]+cy;
  2148.  
  2149.   if (axl*tpx-byl*tpy-cl > 0.0) lsign = 1.0;
  2150.   else lsign = -1.0;
  2151.  
  2152.   if (axr*tpx-byr*tpy-cr < 0.0) rsign = 1.0;
  2153.   else rsign = -1.0;
  2154.  
  2155.   if (axf*tpx-byf*tpy-cf < 0.0) fsign = 1.0;
  2156.   else fsign = -1.0;
  2157. }
  2158.  
  2159.  
  2160.  
  2161.  
  2162.  
  2163.  
  2164.